Durante años, la respuesta a «¿en qué lenguaje se hace IA?» ha sido una sola palabra: Python. Sigue siéndolo para investigar y entrenar. Pero en 2026 Rust ha dejado de ser un invitado y aparece en sitios donde antes ni se planteaba: motores de inferencia, servidores de modelos locales y, desde septiembre, el propio desarrollo de kernels para GPU con respaldo directo de NVIDIA. La pregunta útil no es si Rust sustituye a Python, sino qué capas de la pila de un LLM salen ganando si se escriben en Rust, y cuáles no.
Por qué Python manda (y por qué eso deja hueco)
Python se impuso en aprendizaje automático por productividad, por ecosistema (PyTorch, Transformers, NumPy) y porque casi toda investigación nueva se publica primero con código en Python. Nada de eso ha cambiado.
Lo que a menudo se pasa por alto es que Python rara vez hace el trabajo pesado. Las multiplicaciones de matrices las ejecutan kernels de CUDA, cuBLAS o código en C++; Python es el pegamento que los orquesta. Ese reparto crea dos zonas donde Rust compite con ventaja: el código que rodea al modelo (servidor, colas, streaming, tokenización, gestión de memoria, concurrencia) y, cada vez más, el propio código de los kernels.
Qué aporta Rust en producción
Un servicio que atiende a miles de usuarios con un LLM tiene que repartir peticiones concurrentes, cargar modelos sin disparar la memoria, devolver tokens en streaming y coordinar la GPU sin bloqueos. Ahà cuentan tres cosas:
- Sin recolector de basura. Latencias más predecibles y menos picos de memoria que en un servicio largo en un lenguaje con GC.
- Concurrencia comprobada por el compilador. El sistema de propiedad y préstamos elimina de raÃz las carreras de datos en código seguro.
- Un único binario. Sin entorno virtual, sin versiones de CUDA para Python cruzadas con las del sistema; útil en máquinas aisladas o en el borde.
Con una advertencia importante: Rust no hace más rápido un modelo por sà mismo. La velocidad de generación depende de la arquitectura, el ancho de banda de memoria, la cuantización y la calidad de los kernels. Rust ayuda a que el código alrededor de todo eso sea correcto y eficiente, no a que la GPU compute más deprisa. Y tampoco evita los fallos lógicos ni las fugas de memoria: seguro en memoria no es lo mismo que correcto.
El ecosistema, con datos de hoy
Candle (Hugging Face)
Candle es un framework de ML «minimalista» escrito en Rust, con licencia dual Apache-2.0/MIT y unas 21.000 estrellas en GitHub. Tiene backend de CPU (con MKL en x86 y Accelerate en macOS), CUDA con soporte multi-GPU mediante NCCL, y compilación a WebAssembly para ejecutar modelos en el navegador. Cubre LLaMA, Mistral, Mixtral, Gemma, Phi, Qwen, Falcon y StarCoder, además de Whisper, Stable Diffusion o YOLO. Su atractivo es poder desplegar inferencia sin arrastrar el runtime completo de PyTorch.
mistral.rs
mistral.rs es un motor de inferencia en Rust, licencia MIT, construido sobre Candle (y, pese al nombre, sin relación con Mistral AI). Lo interesante es lo completo que se ha vuelto: PagedAttention con batching continuo, cuantización «in situ» al cargar el modelo (ISQ), formatos GGUF, GPTQ, AWQ y FP8, modelos multimodales con texto, visión, vÃdeo y audio, cliente MCP para herramientas externas y una API compatible con OpenAI, además de interfaz web y métricas en formato Prometheus. Funciona sobre CUDA, Metal en Apple Silicon y CPU, y se puede usar desde Rust o desde Python. Es decir, es un servidor de modelos completo, no un experimento.
Burn
Burn, de Tracel AI (MIT/Apache-2.0), apunta más a entrenar y desplegar con el mismo código. Sus backends aceleradores se apoyan en CubeCL y cubren CUDA, ROCm, Metal, Vulkan y WebGPU; hace fusión automática de kernels, importa modelos ONNX y pesos de PyTorch o Safetensors, y admite WebAssembly y no_std. Un detalle revelador de lo rápido que se mueve todo: el backend LibTorch quedó obsoleto en la versión 0.22 y se ha retirado de la rama principal.
Lo nuevo: CUDA Rust, o escribir kernels de GPU en Rust
El cambio más relevante del año llegó el 8 de septiembre de 2026, cuando NVIDIA publicó en su blog técnico «Introducing CUDA Rust» (Sri Koundinyan, Melih Elibol y Jonathan Bentz). Hasta ahora, desde Rust se podÃan lanzar kernels, pero el kernel se escribÃa en CUDA C++ u otro lenguaje. Ahora hay dos vÃas para escribirlos en Rust nativo:
- SIMT (cuda-oxide). El modelo clásico de CUDA, un hilo por elemento. Es un backend de código personalizado para
rustcque baja desde MIR hasta PTX. Está en alfa temprana y exige un toolchain nightly fijado. - Tile (cutile-rs). Un modelo de más alto nivel: se describe qué hace un tile de datos y el compilador decide cómo mapearlo a la arquitectura, con compilación JIT mediante CUDA Tile IR. Funciona con Rust estable (1.89 o superior), CUDA 13.3 y GPU con compute capability 8.0 o más. NVIDIA recomienda empezar por esta vÃa.
La parte seria es la seguridad: en Tile, los tensores mutables se parten en porciones disjuntas, de modo que ningún bloque puede solapar la escritura de otro, y el compilador rechaza el aliasing de buffers con los mismos errores de siempre del borrow checker. NVIDIA es clara con la madurez: la cobertura es incompleta, las APIs van a cambiar y CUDA C++ y CUDA Python siguen siendo las cadenas de herramientas de producción. Añade que cutile-rs ya lo usan proyectos externos, entre ellos mistral.rs y el motor Grout de Hugging Face.
Qué dicen los números (y qué no)
El artÃculo académico «Fearless Concurrency on the GPU» (Elibol, Roesch, Gelado, Buehler y Garland; enviado en junio y revisado en septiembre de 2026) describe cuTile Rust y demuestra que su superficie segura está libre de carreras de datos bajo el modelo de memoria de Tile IR. La seguridad de lÃmites todavÃa requiere comprobaciones en ejecución, que el compilador elimina cuando puede demostrar que sobran.
Los resultados que dan los autores:
- Unos 7 TB/s en operaciones elemento a elemento sobre una NVIDIA B200.
- 2,1 PFlop/s en GEMM en la B200, el 98 % de cuBLAS según el texto original.
- Con Grout, un motor de inferencia Qwen3 en Rust hecho con Hugging Face: 171 tokens/s con Qwen3-4B en una RTX 5090 y 82 tokens/s con Qwen3-32B en la B200, ambos en decodificación con lote de 1, con rendimiento que los autores describen como equiparable a vLLM y SGLang.
Hay que leerlos con calma. Son mediciones en configuraciones concretas, con decodificación de una sola secuencia, no un benchmark de servicio con cientos de peticiones concurrentes. Además, otras fuentes del proyecto citan cifras de GEMM distintas con otra referencia (alrededor del 92 % del pico en f16 en la B200, frente al 96 % o 98 % de cuBLAS según la fuente), asà que conviene citar siempre la medición y su base de comparación. Y el proyecto se presenta a sà mismo como software de investigación en fase temprana.
El contrapunto: entrenar en Rust todavÃa duele
El informe «Training a Language Model End-to-End in Rust: An Experience Report», de Arif Adito, es la dosis de realismo. El autor preentrenó un modelo de unos 0,4B de parámetros, orientado sobre todo al bengalÃ, sin PyTorch ni Python en el bucle de entrenamiento, con unas 54,6 horas en una H100 alquilada y un coste de unos 164 dólares. Lo presenta como un logro técnico, no como una recomendación.
Lo más útil es el catálogo de fallos que encontró: cinco defectos en Candle (entre ellos, kernels fusionados que dejaban gradientes a cero sin avisar) y tres en Burn (un paso de retropropagación que rendÃa en torno al 3 % del teórico de la GPU y una ruta de fusión que provocaba un segfault a escala de miles de millones de parámetros). Ninguno se veÃa mirando la curva de pérdida. Para detectarlos propone una comprobación sencilla y reutilizable: tras un forward y un backward, verificar que cada parámetro entrenable recibe un gradiente finito y distinto de cero.
Su conclusión es la que más pesa: terminó el entrenamiento en PyTorch y se quedó con Rust para servir el modelo en dispositivo.
Rust frente a Python, capa por capa
Capa | Python | Rust |
Investigación y prototipos | Es el estándar | Poco terreno |
Entrenamiento | PyTorch domina | Posible, con fallos documentados |
Inferencia local y servidores | Madura (vLLM, SGLang) | Creciendo rápido (mistral.rs, Candle) |
Orquestación, agentes, herramientas | Muy usado | Buena opción cuando importan concurrencia y aislamiento |
Kernels de GPU | CUDA C++ y CUDA Python, en producción | CUDA Rust, en alfa o fase temprana |
Dónde tiene más sentido empezar
- Inferencia local y en el borde. Un binario, WebAssembly, Apple Silicon o CPU sin Python de por medio.
- Agentes y herramientas. Ejecución de herramientas, red, estado y permisos son problemas de sistemas, donde los lÃmites claros de Rust ayudan.
- Servidores de inferencia. Colas, streaming y reparto de GPU entre peticiones.
- Software con requisitos de seguridad. Evita clases enteras de errores de memoria, aunque no los fallos de lógica ni los de seguridad a nivel de aplicación.
Rust en herramientas propias, con matiz
Por aquà también se ha construido con Rust, aunque en un terreno distinto al de la IA. mboxShell es un visor de archivos MBOX para terminal, con licencia MIT, pensado para abrir buzones de correo enormes sin cargarlos enteros en memoria; CrawlForge es un rastreador para auditorÃas SEO con base de datos SQLite y comparación entre rastreos, bajo licencia Apache-2.0. Ninguno es un proyecto de IA, y precisamente por eso sirven de ejemplo: lo que Rust aporta (binario único, memoria predecible, paralelismo sin sobresaltos) es lo mismo que se busca en un servidor de inferencia. Si ese perfil encaja con lo que se quiere montar, el salto de herramienta de sistemas a servicio de IA es más corto de lo que parece.
Conclusión
Rust no es «el lenguaje perfecto para los LLM», y quien lo afirme está ignorando los datos: en entrenamiento, el ecosistema sigue por detrás y hay fallos documentados en los dos frameworks principales. Pero tampoco es un lenguaje ajeno a la IA. En inferencia ya es una opción práctica, y la entrada de NVIDIA en los kernels en Rust abre una lÃnea que hace un año no existÃa. Lo razonable hoy es una arquitectura mixta: Python para investigar y entrenar, Rust para servir, orquestar y, cuando madure, para escribir parte de lo que corre en la GPU.
Este artÃculo parte de una pieza de opinión publicada en Medium, ampliada y corregida con las fuentes primarias (blog de NVIDIA, artÃculos de arXiv y repositorios oficiales).
Fuentes
- Rothy Yorn, «Is Rust the Perfect Language for LLMs?» (Medium, 27-oct-2026), artÃculo de partida
- NVIDIA Technical Blog, «Introducing CUDA Rust: Two Tracks for Writing GPU Kernels» (8-sep-2026)
- Elibol et al., «Fearless Concurrency on the GPU» (arXiv:2606.15991)
- Adito, «Training a Language Model End-to-End in Rust: An Experience Report» (arXiv:2609.25008)
- NVlabs/cutile-rs
- NVlabs/cuda-oxide
- huggingface/candle
- EricLBuehler/mistral.rs
- tracel-ai/burn
Imagen: Pexels / Sergei Starostin